﻿using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Data;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using CasasJusticia.Messaging.Contexto.CasasJusticia;
using CasasJusticia.Messaging.Modelo;
using FluorineFx;

namespace CasasJusticia.Messaging.Contexto
{
    [RemotingService("Estadisticas")]
    public partial class ConsultasEstadisticas
    {

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.EstadoCivil")]
        public DataTable EstadoCivil(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");
                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdEstadoCivil } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.EstadoCivil
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdEstadoCivil = entidad.Key.IdEstadoCivil,
                                                       Total = entidad.Count(),
                                                       NomEstadoCivil = querySolicitantes.Where(x => x.IdEstadoCivil == entidad.Key.IdEstadoCivil).Select(x => x.NomEstadoCivil).FirstOrDefault()
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.EstadoCivil>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdEstadoCivil } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.EstadoCivil
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdEstadoCivil = estado.Key.IdEstadoCivil,
                                                      Total = estado.Count(),
                                                      NomEstadoCivil = querySolicitantes.Where(x => x.IdEstadoCivil == estado.Key.IdEstadoCivil).Select(x => x.NomEstadoCivil).FirstOrDefault()
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.EstadoCivil>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdEstadoCivil } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.EstadoCivil
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdEstadoCivil = motivo.Key.IdEstadoCivil,
                                                      Total = motivo.Count(),
                                                      NomEstadoCivil = querySolicitantes.Where(x => x.IdEstadoCivil == motivo.Key.IdEstadoCivil).Select(x => x.NomEstadoCivil).FirstOrDefault()
                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.EstadoCivil>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.EstadoCivil>(new Collection<Estadisticas.EstadoCivil>());
                }
                
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.Estrato")]
        public DataTable Estrato(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");

                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdEstrato } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.Estrato
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdEstrato = entidad.Key.IdEstrato,
                                                       Total = entidad.Count(),
                                                       NomEstrato = querySolicitantes.Where(x => x.IdEstrato == entidad.Key.IdEstrato).Select(x => x.NomEstrato).FirstOrDefault(),
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.Estrato>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdEstrato } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.Estrato
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdEstrato = estado.Key.IdEstrato,
                                                      Total = estado.Count(),
                                                      NomEstrato = querySolicitantes.Where(x => x.IdEstrato == estado.Key.IdEstrato).Select(x => x.NomEstrato).FirstOrDefault(),
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Estrato>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdEstrato } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.Estrato
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdEstrato = motivo.Key.IdEstrato,
                                                      Total = motivo.Count(),
                                                      NomEstrato = querySolicitantes.Where(x => x.IdEstrato == motivo.Key.IdEstrato).Select(x => x.NomEstrato).FirstOrDefault(),
                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Estrato>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.Estrato>(new Collection<Estadisticas.Estrato>());
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.Genero")]
        public DataTable Genero(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");

                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdGenero } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.Genero
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdGenero = entidad.Key.IdGenero,
                                                       Total = entidad.Count(),
                                                       NomGenero = querySolicitantes.Where(x => x.IdGenero == entidad.Key.IdGenero).Select(x => x.NomGenero).FirstOrDefault()
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.Genero>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdGenero } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.Genero
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdGenero = estado.Key.IdGenero,
                                                      Total = estado.Count(),
                                                      NomGenero = querySolicitantes.Where(x => x.IdGenero == estado.Key.IdGenero).Select(x => x.NomGenero).FirstOrDefault()
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Genero>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdGenero } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.Genero
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdGenero = motivo.Key.IdGenero,
                                                      Total = motivo.Count(),
                                                      NomGenero = querySolicitantes.Where(x => x.IdGenero == motivo.Key.IdGenero).Select(x => x.NomGenero).FirstOrDefault()

                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Genero>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.Genero>(new Collection<Estadisticas.Genero>());
                }                
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.GrupoEtario")]
        public DataTable GrupoEtario(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");

                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdGrupoEtario } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.GrupoEtario
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdGrupoEtario = entidad.Key.IdGrupoEtario,
                                                       Total = entidad.Count(),
                                                       NomGrupoEtario = querySolicitantes.Where(x => x.IdGrupoEtario == entidad.Key.IdGrupoEtario).Select(x => x.NomGrupoEtario).FirstOrDefault()
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.GrupoEtario>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdGrupoEtario } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.GrupoEtario
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdGrupoEtario = estado.Key.IdGrupoEtario,
                                                      Total = estado.Count(),
                                                      NomGrupoEtario = querySolicitantes.Where(x => x.IdGrupoEtario == estado.Key.IdGrupoEtario).Select(x => x.NomGrupoEtario).FirstOrDefault()
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.GrupoEtario>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdGrupoEtario } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.GrupoEtario
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdGrupoEtario = motivo.Key.IdGrupoEtario,
                                                      Total = motivo.Count(),
                                                      NomGrupoEtario = querySolicitantes.Where(x => x.IdGrupoEtario == motivo.Key.IdGrupoEtario).Select(x => x.NomGrupoEtario).FirstOrDefault()
                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.GrupoEtario>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.GrupoEtario>(new Collection<Estadisticas.GrupoEtario>());
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.GrupoEtnico")]
        public DataTable GrupoEtnico(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");

                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdEtnia } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.Etnia
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdEtnia = entidad.Key.IdEtnia,
                                                       NomEtnia = querySolicitantes.Where(x => x.IdEtnia == entidad.Key.IdEtnia).Select(x => x.NomEtnia).FirstOrDefault(),
                                                       Total = entidad.Count()
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.Etnia>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdEtnia } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.Etnia
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdEtnia = estado.Key.IdEtnia,
                                                      NomEtnia = querySolicitantes.Where(x => x.IdEtnia == estado.Key.IdEtnia).Select(x => x.NomEtnia).FirstOrDefault(),
                                                      Total = estado.Count()
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Etnia>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdEtnia } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.Etnia
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdEtnia = motivo.Key.IdEtnia,
                                                      NomEtnia = querySolicitantes.Where(x => x.IdEtnia == motivo.Key.IdEtnia).Select(x => x.NomEtnia).FirstOrDefault(),
                                                      Total = motivo.Count()
                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Etnia>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.Etnia>(new Collection<Estadisticas.Etnia>());
                }                                
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.NivelEducativo")]
        public DataTable NivelEducativo(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");
                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdNivelEducativo } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.NivelEducativo
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdNivelEducativo = entidad.Key.IdNivelEducativo,
                                                       NomNivelEducativo = querySolicitantes.Where(x => x.IdNivelEducativo == entidad.Key.IdNivelEducativo).Select(x => x.NomNivelEducativo).FirstOrDefault(),
                                                       Total = entidad.Count()
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.NivelEducativo>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdNivelEducativo } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.NivelEducativo
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdNivelEducativo = estado.Key.IdNivelEducativo,
                                                      NomNivelEducativo = querySolicitantes.Where(x => x.IdNivelEducativo == estado.Key.IdNivelEducativo).Select(x => x.NomNivelEducativo).FirstOrDefault(),
                                                      Total = estado.Count()
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.NivelEducativo>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdNivelEducativo } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.NivelEducativo
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdNivelEducativo = motivo.Key.IdNivelEducativo,
                                                      NomNivelEducativo = querySolicitantes.Where(x => x.IdNivelEducativo == motivo.Key.IdNivelEducativo).Select(x => x.NomNivelEducativo).FirstOrDefault(),
                                                      Total = motivo.Count()
                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.NivelEducativo>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.NivelEducativo>(new Collection<Estadisticas.NivelEducativo>());
                }                
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.ProgramaBenefico")]
        public DataTable ProgramaBenefico(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");

                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdProgramaBenefico } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.ProgramaBenefico
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdProgramaBenefico = entidad.Key.IdProgramaBenefico,
                                                       NomProgramaBenefico = querySolicitantes.Where(x => x.IdProgramaBenefico == entidad.Key.IdProgramaBenefico).Select(x => x.NomProgramaBenefico).FirstOrDefault(),
                                                       Total = entidad.Count()
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.ProgramaBenefico>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdProgramaBenefico } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.ProgramaBenefico
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdProgramaBenefico = estado.Key.IdProgramaBenefico,
                                                      NomProgramaBenefico = querySolicitantes.Where(x => x.IdProgramaBenefico == estado.Key.IdProgramaBenefico).Select(x => x.NomProgramaBenefico).FirstOrDefault(),
                                                      Total = estado.Count()
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.ProgramaBenefico>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdProgramaBenefico } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.ProgramaBenefico
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdProgramaBenefico = motivo.Key.IdProgramaBenefico,
                                                      NomProgramaBenefico = querySolicitantes.Where(x => x.IdProgramaBenefico == motivo.Key.IdProgramaBenefico).Select(x => x.NomProgramaBenefico).FirstOrDefault(),
                                                      Total = motivo.Count()
                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.ProgramaBenefico>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.ProgramaBenefico>(new Collection<Estadisticas.ProgramaBenefico>());
                }                                
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="tipoSolicitud"></param>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Estadisticas.Sexo")]
        public DataTable Sexo(string tipoSolicitud, Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                if (string.IsNullOrEmpty(tipoSolicitud))
                    throw new Exception("Debe indicar un tipo de solicitud");

                Collection<Estadisticas.Remision> querySolicitantes = this.ObtenerConsulta(idsDepartamento, idsMunicipio, idsLocalidad, idsCasaJusticia, fechaInicial, fechaFinal);

                switch (tipoSolicitud.ToLower())
                {
                    case "entidad":
                        var resultadoPorEntidad = (from solicitante in querySolicitantes
                                                   group solicitante by new { solicitante.IdEntidad, solicitante.IdSexo } into entidad
                                                   //orderby entidad.Key.NombreEntidad ascending
                                                   select new Estadisticas.Sexo
                                                   {
                                                       IdEntidad = entidad.Key.IdEntidad,
                                                       NombreEntidad = querySolicitantes.Where(x => x.IdEntidad == entidad.Key.IdEntidad).Select(x => x.NombreEntidad).FirstOrDefault(),
                                                       IdSexo = entidad.Key.IdSexo,
                                                       NomSexo = querySolicitantes.Where(x => x.IdSexo == entidad.Key.IdSexo).Select(x => x.NomSexo).FirstOrDefault(),
                                                       Total = entidad.Count()
                                                   }).OrderBy(x => x.NombreEntidad);
                        return this.QueryToDataTable<Estadisticas.Sexo>(resultadoPorEntidad);
                    case "estado":
                        var resultadoPorEstado = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdEstadoSolicitud, solicitante.IdSexo } into estado
                                                  //orderby estado.Key.NomEstadoSolicitud ascending
                                                  select new Estadisticas.Sexo
                                                  {
                                                      IdEstadoSolicitud = estado.Key.IdEstadoSolicitud,
                                                      NomEstadoSolicitud = querySolicitantes.Where(x => x.IdEstadoSolicitud == estado.Key.IdEstadoSolicitud).Select(x => x.NomEstadoSolicitud).FirstOrDefault(),
                                                      IdSexo = estado.Key.IdSexo,
                                                      NomSexo = querySolicitantes.Where(x => x.IdSexo == estado.Key.IdSexo).Select(x => x.NomSexo).FirstOrDefault(),
                                                      Total = estado.Count()
                                                  }).OrderBy(x => x.NomEstadoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Sexo>(resultadoPorEstado);
                    case "motivo":
                        var resultadoPorMotivo = (from solicitante in querySolicitantes
                                                  group solicitante by new { solicitante.IdMotivoSolicitud, solicitante.IdSexo } into motivo
                                                  //orderby motivo.Key.TemaMotivoSolicitud ascending
                                                  select new Estadisticas.Sexo
                                                  {
                                                      IdMotivoSolicitud = motivo.Key.IdMotivoSolicitud,
                                                      NomMotivoSolicitud = querySolicitantes.Where(x => x.IdMotivoSolicitud == motivo.Key.IdMotivoSolicitud).Select(x => x.TemaMotivoSolicitud).FirstOrDefault(),
                                                      IdSexo = motivo.Key.IdSexo,
                                                      NomSexo = querySolicitantes.Where(x => x.IdSexo == motivo.Key.IdSexo).Select(x => x.NomSexo).FirstOrDefault(),
                                                      Total = motivo.Count()
                                                  }).OrderBy(x => x.NomMotivoSolicitud);
                        return this.QueryToDataTable<Estadisticas.Sexo>(resultadoPorMotivo);
                    default:
                        return this.QueryToDataTable<Estadisticas.Sexo>(new Collection<Estadisticas.Sexo>());
                }           
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        #region Jerarquia

        /// <summary>
        /// 
        /// </summary>
        /// <param name="idMunicipio"></param>
        /// <param name="idLocalidad"></param>
        /// <param name="idCasasJusticia"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Departamento.Departamento")]
        public DataTable ObtenerCasasJusticia(string idMunicipio, string idLocalidad, Array idCasasJusticia)
        {
            try
            {
                if (string.IsNullOrEmpty(idMunicipio) && string.IsNullOrEmpty(idLocalidad))
                    return Utilidades.ConsultaToDataTable<EntidadPorCasa>(new Collection<EntidadPorCasa>());

                int idLocalidadN = !string.IsNullOrEmpty(idLocalidad) ? Convert.ToInt32(idLocalidad) : 0;

                Collection<EntidadPorCasa> entidadesPorCasasJusticia = Utilidades.EntidadesPorCasa();

                List<int> codigosCasasJusticia = Utilidades.ArmarListaValoresDeArray(idCasasJusticia);

                if (string.IsNullOrEmpty(idLocalidad))
                {
                    var queryCasasJusticia = from entidadPorCasa in entidadesPorCasasJusticia
                                             where codigosCasasJusticia.Contains(entidadPorCasa.IdCasaJusticia) && entidadPorCasa.IdMunicipio.Equals(idMunicipio)                                           
                                             group entidadPorCasa by new { IdCasaJusticia = entidadPorCasa.IdCasaJusticia, NomCasaJusticia = entidadPorCasa.NomCasaJusticia } into cj
                                             orderby cj.Key.NomCasaJusticia
                                             select new EntidadPorCasa
                                             {
                                                 IdCasaJusticia = cj.Key.IdCasaJusticia,
                                                 NomCasaJusticia = cj.Key.NomCasaJusticia,
                                                 IdDepartamento = entidadesPorCasasJusticia.Where(x => x.IdCasaJusticia == cj.Key.IdCasaJusticia).Select(x => x.IdDepartamento).FirstOrDefault(),
                                                 IdMunicipio = entidadesPorCasasJusticia.Where(x => x.IdCasaJusticia == cj.Key.IdCasaJusticia).Select(x => x.IdMunicipio).FirstOrDefault(),
                                             };

                    return Utilidades.ConsultaToDataTable<EntidadPorCasa>(queryCasasJusticia.ToArray());
                }
                else
                {
                    var queryCasasJusticia = from entidadPorCasa in entidadesPorCasasJusticia
                                             where codigosCasasJusticia.Contains(entidadPorCasa.IdCasaJusticia) && entidadPorCasa.IdMunicipio.Equals(idMunicipio)
                                             && entidadPorCasa.IdLocalidad == idLocalidadN
                                             group entidadPorCasa by new { IdCasaJusticia = entidadPorCasa.IdCasaJusticia, NomCasaJusticia = entidadPorCasa.NomCasaJusticia } into cj
                                             orderby cj.Key.NomCasaJusticia
                                             select new EntidadPorCasa
                                             {
                                                 IdCasaJusticia = cj.Key.IdCasaJusticia,
                                                 NomCasaJusticia = cj.Key.NomCasaJusticia,
                                                 IdDepartamento = entidadesPorCasasJusticia.Where(x => x.IdCasaJusticia == cj.Key.IdCasaJusticia).Select(x => x.IdDepartamento).FirstOrDefault(),
                                                 IdMunicipio = entidadesPorCasasJusticia.Where(x => x.IdCasaJusticia == cj.Key.IdCasaJusticia).Select(x => x.IdMunicipio).FirstOrDefault(),
                                             };

                    return Utilidades.ConsultaToDataTable<EntidadPorCasa>(queryCasasJusticia.ToArray());
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Departamento.Departamento")]
        public DataTable ObtenerDepartamentos()
        {
            try
            {                
                Collection<EntidadPorCasa> entidades = Utilidades.EntidadesPorCasa();

                var queryDepartamentos = from entidad in entidades
                                         group entidad by new { entidad.IdDepartamento, entidad.NomDepartamento } into dpto
                                         orderby dpto.Key.NomDepartamento ascending
                                         select new Jurisdicciones.Departamento
                                         {
                                             IdDepartamento = dpto.Key.IdDepartamento,
                                             NomDepartamento = dpto.Key.NomDepartamento
                                         };

                return Utilidades.ConsultaToDataTable<Jurisdicciones.Departamento>(queryDepartamentos.ToArray());
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="idMunicipio"></param>
        /// <param name="idCasasJusticia"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.DivisionMunicipal")]
        public DataTable ObtenerLocalidades(string idMunicipio, Array idCasasJusticia)
        {
            try
            {
                DivisionMunicipal dm = new DivisionMunicipal();
                return dm.ConsultaDivMunicipalPorMpio(idMunicipio, idCasasJusticia);
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="idDepartamento"></param>
        /// <returns></returns>
        [DataTableType("CasasJusticia.Modelo.Municipio.Municipio")]
        public DataTable ObtenerMunicipios(string idDepartamento)
        {
            try
            {   
                Collection<EntidadPorCasa> entidades = Utilidades.EntidadesPorCasa();

                var queryMunicipios = from entidad in entidades
                                      where entidad.IdDepartamento.Equals(idDepartamento)
                                      group entidad by new { entidad.IdDepartamento, entidad.IdMunicipio, entidad.NomMunicipio} into municipio
                                      orderby municipio.Key.NomMunicipio ascending
                                      select new Jurisdicciones.Municipio
                                      {
                                          IdDepartamento = municipio.Key.IdDepartamento,
                                          IdMunicipio = municipio.Key.IdMunicipio,
                                          NomMunicipio = municipio.Key.NomMunicipio,
                                          TieneLocalidades = entidades.Where(x => x.IdMunicipio == municipio.Key.IdMunicipio).Select(x => x.TieneLocalidades).FirstOrDefault()
                                      };

                return this.QueryToDataTable<Jurisdicciones.Municipio>(queryMunicipios.ToArray());
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        #endregion

        #region Métodos y Funciones

        /// <summary>
        /// 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="source"></param>
        /// <returns></returns>
        private DataTable QueryToDataTable<T>(IEnumerable<T> source)
        {
            PropertyInfo[] propiedades = typeof(T).GetProperties();

            DataTable dataTable = new DataTable();

            foreach (var propiedad in propiedades)
                dataTable.Columns.Add(propiedad.Name, propiedad.PropertyType);

            foreach (var item in source)
            {
                DataRow row = dataTable.NewRow();

                foreach (var prop in propiedades)
                    row[prop.Name] = prop.GetValue(item, null);

                dataTable.Rows.Add(row);
            }

            return dataTable;
        }

        /*
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        private Collection<Estadisticas.Remision> ObtenerConsulta()
        {
            try
            {
                Collection<EntidadPorCasa> entidades = Utilidades.EntidadesPorCasa();

                using (EntidadesCasasJusticia contexto = new EntidadesCasasJusticia())
                {
                    var querySolicitantes = from remision in contexto.View_Remision
                                            select new Estadisticas.Remision
                                            {
                                                IdEntidad = remision.IdEntidad,
                                                NombreEntidad = remision.NomEntidad,
                                                IdEstadoSolicitud = remision.IdEstadoSolicitud,
                                                NomEstadoSolicitud = remision.NomEstadoSolicitud,
                                                IdMotivoSolicitud = remision.IdMotivoSolicitud,
                                                TemaMotivoSolicitud = remision.TemaMotivoSolicitud,
                                                IdEstadoCivil = remision.IdEstadoCivil,
                                                NomEstadoCivil = remision.EstadoCivil,
                                                IdEstrato = remision.IdEstrato,
                                                NomEstrato = remision.Estrato,
                                                IdGenero = remision.IdGenero,
                                                NomGenero = remision.Genero,
                                                IdGrupoEtario = remision.IdGrupoEtario,
                                                NomGrupoEtario = remision.NomGrupoEtario,
                                                IdNivelEducativo = remision.IdNivelEducativo,
                                                NomNivelEducativo = remision.NomNivelEducativo,
                                                IdProgramaBenefico = remision.IdProgramaBeneficio,
                                                NomProgramaBenefico = remision.NomProgramaBeneficio,
                                                IdSexo = remision.IdSexo,
                                                NomSexo = remision.Sexo,
                                                IdEtnia = remision.IdEtnia,
                                                NomEtnia = remision.Etnia,
                                                IdCasaJusticia = remision.IdCasaJusticia,
                                                IdDepartamento = remision.IdDeptoCasa,
                                                NomDepartamento = remision.DeptoCasa,
                                                IdMunicipio = remision.IdMuniCasa,
                                                NomMunicipio = remision.MuniCasa
                                            };

                    Collection<Estadisticas.Remision> estadisticas = new Collection<Estadisticas.Remision>();

                    foreach (var q in querySolicitantes)
                        estadisticas.Add(new Estadisticas.Remision
                        {
                            IdEntidad = q.IdEntidad,
                            NombreEntidad = q.NombreEntidad,
                            IdEstadoSolicitud = q.IdEstadoSolicitud,
                            NomEstadoSolicitud = q.NomEstadoSolicitud,
                            IdMotivoSolicitud = q.IdMotivoSolicitud,
                            TemaMotivoSolicitud = q.TemaMotivoSolicitud,
                            IdEstadoCivil = q.IdEstadoCivil,
                            NomEstadoCivil = q.NomEstadoCivil,
                            IdEstrato = q.IdEstrato,
                            NomEstrato = q.NomEstrato,
                            IdGenero = q.IdGenero,
                            NomGenero = q.NomGenero,
                            IdGrupoEtario = q.IdGrupoEtario,
                            NomGrupoEtario = q.NomGrupoEtario,
                            IdNivelEducativo = q.IdNivelEducativo,
                            NomNivelEducativo = q.NomNivelEducativo,
                            IdProgramaBenefico = q.IdProgramaBenefico,
                            NomProgramaBenefico = q.NomProgramaBenefico,
                            IdSexo = q.IdSexo,
                            NomSexo = q.NomSexo,
                            IdEtnia = q.IdEtnia,
                            NomEtnia = q.NomEtnia,
                            IdCasaJusticia = q.IdCasaJusticia,
                            IdDepartamento = !string.IsNullOrEmpty(q.IdDepartamento) ? q.IdDepartamento.Replace(" ", "") : "",
                            NomDepartamento = q.NomDepartamento,
                            IdMunicipio = !string.IsNullOrEmpty(q.IdMunicipio) ? q.IdMunicipio.Replace(" ", "") : "",
                            NomMunicipio = q.NomMunicipio
                        });

                    return new Collection<Estadisticas.Remision>(querySolicitantes.ToArray());
                }
            }
            catch (Exception e)
            {
                throw new Exception(string.Format("Error al obtener consulta básica: {0}", e.Message));
            }
        }*/

        /// <summary>
        /// 
        /// </summary>
        /// <param name="idsDepartamento"></param>
        /// <param name="idsMunicipio"></param>
        /// <param name="fechaInicial"></param>
        /// <param name="fechaFinal"></param>
        /// <returns></returns>
        private Collection<Estadisticas.Remision> ObtenerConsulta(Array idsDepartamento, Array idsMunicipio, Array idsLocalidad, Array idsCasaJusticia, string fechaInicial, string fechaFinal)
        {
            try
            {
                DateTime fechaInicio = DateTime.ParseExact(fechaInicial, "dd-MM-yyyy", CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault);
                DateTime fechaFin = DateTime.ParseExact(fechaFinal, "dd-MM-yyyy", CultureInfo.InvariantCulture, DateTimeStyles.NoCurrentDateDefault);

                using (EntidadesCasasJusticia contexto = new EntidadesCasasJusticia())
                {
                    var queryRemision = from remision in contexto.View_Remision
                                        where remision.FechaSolicitud >= fechaInicio && remision.FechaSolicitud <= fechaFin 
                                        && remision.EstEntidadCasa.Replace(" ", "").Equals("A")
                                        select new Estadisticas.Remision
                                        {
                                            IdEntidad = remision.IdEntidad,
                                            NombreEntidad = remision.NomEntidad,
                                            IdEstadoSolicitud = remision.IdEstadoSolicitud,
                                            NomEstadoSolicitud = remision.NomEstadoSolicitud,
                                            IdMotivoSolicitud = remision.IdMotivoSolicitud,
                                            TemaMotivoSolicitud = remision.TemaMotivoSolicitud,
                                            IdEstadoCivil = remision.IdEstadoCivil,
                                            NomEstadoCivil = remision.EstadoCivil,
                                            IdEstrato = remision.IdEstrato,
                                            NomEstrato = remision.Estrato,
                                            IdGenero = remision.IdGenero,
                                            NomGenero = remision.Genero,
                                            IdGrupoEtario = remision.IdGrupoEtario,
                                            NomGrupoEtario = remision.NomGrupoEtario,
                                            IdNivelEducativo = remision.IdNivelEducativo,
                                            NomNivelEducativo = remision.NomNivelEducativo,
                                            IdProgramaBenefico = remision.IdProgramaBeneficio,
                                            NomProgramaBenefico = remision.NomProgramaBeneficio,
                                            IdSexo = remision.IdSexo,
                                            NomSexo = remision.Sexo,
                                            IdEtnia = remision.IdEtnia,
                                            NomEtnia = remision.Etnia,
                                            IdCasaJusticia = remision.IdCasaJusticia,
                                            IdDepartamento = remision.IdDeptoCasa,
                                            NomDepartamento = remision.DeptoCasa,
                                            IdMunicipio = remision.IdMuniCasa,
                                            NomMunicipio = remision.MuniCasa,
                                            IdDivisionMunicipal = remision.IdDivMunCasa                                            
                                        };

                    Collection<Estadisticas.Remision> estadisticas = new Collection<Estadisticas.Remision>();

                    foreach (var q in queryRemision)
                        estadisticas.Add(new Estadisticas.Remision
                        {
                            IdEntidad = q.IdEntidad,
                            NombreEntidad = q.NombreEntidad,
                            IdEstadoSolicitud = q.IdEstadoSolicitud,
                            NomEstadoSolicitud = q.NomEstadoSolicitud,
                            IdMotivoSolicitud = q.IdMotivoSolicitud,
                            TemaMotivoSolicitud = q.TemaMotivoSolicitud,
                            IdEstadoCivil = q.IdEstadoCivil,
                            NomEstadoCivil = q.NomEstadoCivil,
                            IdEstrato = q.IdEstrato,
                            NomEstrato = q.NomEstrato,
                            IdGenero = q.IdGenero,
                            NomGenero = q.NomGenero,
                            IdGrupoEtario = q.IdGrupoEtario,
                            NomGrupoEtario = q.NomGrupoEtario,
                            IdNivelEducativo = q.IdNivelEducativo,
                            NomNivelEducativo = q.NomNivelEducativo,
                            IdProgramaBenefico = q.IdProgramaBenefico,
                            NomProgramaBenefico = q.NomProgramaBenefico,
                            IdSexo = q.IdSexo,
                            NomSexo = q.NomSexo,
                            IdEtnia = q.IdEtnia,
                            NomEtnia = q.NomEtnia,
                            IdCasaJusticia = q.IdCasaJusticia,
                            IdDepartamento = !string.IsNullOrEmpty(q.IdDepartamento) ? q.IdDepartamento.Replace(" ", "") : "",
                            NomDepartamento = q.NomDepartamento,
                            IdMunicipio = !string.IsNullOrEmpty(q.IdMunicipio) ? q.IdMunicipio.Replace(" ", "") : "",
                            NomMunicipio = q.NomMunicipio
                        });

                    //Casas de justicia + localidad
                    if (idsDepartamento != null && idsMunicipio != null && idsLocalidad != null && idsCasaJusticia != null)
                    {
                        //List<string> codigosDepartamento = Utilidades.ArmarListaValoresDeArray2(idsDepartamento);
                        List<string> codigosMunicipio = Utilidades.ArmarListaValoresDeArray2(idsMunicipio);
                        List<int> codigosLocalidad = Utilidades.ArmarListaValoresDeArray(idsLocalidad);
                        List<int> codigosCasasJusticia = Utilidades.ArmarListaValoresDeArray(idsCasaJusticia);
                        return new Collection<Estadisticas.Remision>(estadisticas.Where(x => codigosMunicipio.Contains(x.IdMunicipio)
                                                                        && codigosLocalidad.Contains(x.IdDivisionMunicipal)
                                                                        && codigosCasasJusticia.Contains(x.IdCasaJusticia)).ToArray());
                    }
                    //Casas de justicia
                    else if(idsDepartamento != null && idsMunicipio != null && idsLocalidad == null && idsCasaJusticia != null)
                    {
                        List<string> codigosMunicipio = Utilidades.ArmarListaValoresDeArray2(idsMunicipio);
                        //List<int> codigosLocalidad = Utilidades.ArmarListaValoresDeArray(idsLocalidad);
                        List<int> codigosCasasJusticia = Utilidades.ArmarListaValoresDeArray(idsCasaJusticia);
                        return new Collection<Estadisticas.Remision>(estadisticas.Where(x => codigosMunicipio.Contains(x.IdMunicipio)                                                                        
                                                                        && codigosCasasJusticia.Contains(x.IdCasaJusticia)).ToArray());
                    }
                    //Localidad
                    else if (idsDepartamento != null && idsMunicipio != null && idsLocalidad != null)
                    {
                        //List<string> codigosDepartamento = Utilidades.ArmarListaValoresDeArray2(idsDepartamento);
                        List<string> codigosMunicipio = Utilidades.ArmarListaValoresDeArray2(idsMunicipio);
                        List<int> codigosLocalidad = Utilidades.ArmarListaValoresDeArray(idsLocalidad);
                        return new Collection<Estadisticas.Remision>(estadisticas.Where(x => codigosMunicipio.Contains(x.IdMunicipio) 
                                                                        && codigosLocalidad.Contains(x.IdDivisionMunicipal)).ToArray());
                    }
                    //Municipio
                    else if (idsDepartamento != null && idsMunicipio != null/* && idsLocalidad == null*/)
                    {
                        List<string> codigosDepartamento = Utilidades.ArmarListaValoresDeArray2(idsDepartamento);
                        List<string> codigosMunicipio = Utilidades.ArmarListaValoresDeArray2(idsMunicipio);
                        return new Collection<Estadisticas.Remision>(estadisticas.Where(x => codigosMunicipio.Contains(x.IdMunicipio)).ToArray());
                    }
                    //Departamento
                    else if (idsDepartamento != null && idsMunicipio == null/* && idsLocalidad == null*/)
                    {
                        List<string> codigosDepartamento = Utilidades.ArmarListaValoresDeArray2(idsDepartamento);

                        foreach (var q in estadisticas)
                            System.Diagnostics.Debug.WriteLine(string.Format("Existe '{0}' en la lista? : {1}", q.IdDepartamento,codigosDepartamento.Contains(q.IdDepartamento)));

                        return new Collection<Estadisticas.Remision>(estadisticas.Where(x => codigosDepartamento.Contains(x.IdDepartamento)).ToArray());
                    }
                    //Nación
                    else
                        return new Collection<Estadisticas.Remision>(queryRemision.ToArray());
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.Message);
            }
        }

        #endregion
    }
}
